/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('ehpcinstant', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AddImageRequest {
  containerImageSpec?: {
    isACREnterprise?: boolean(name='IsACREnterprise', example='True'),
    isACRRegistry?: boolean(name='IsACRRegistry', example='True'),
    registryCredential?: {
      password?: string(name='Password', example='userpassword'),
      server?: string(name='Server', example='registry-vpc.cn-hangzhou.aliyuncs.com'),
      userName?: string(name='UserName', example='username'),
    }(name='RegistryCredential'),
    registryCriId?: string(name='RegistryCriId', example='cri-xyz795ygf8k9****'),
    registryUrl?: string(name='RegistryUrl', example='registry-vpc.cn-hangzhou.aliyuncs.com/ehpc_open/nginx:latest'),
  }(name='ContainerImageSpec'),
  description?: string(name='Description'),
  imageType?: string(name='ImageType'),
  imageVersion?: string(name='ImageVersion', example='V1.0'),
  name?: string(name='Name', description='This parameter is required.', example='app-image'),
  VMImageSpec?: {
    imageId?: string(name='ImageId', example='m-bp1akkkr1rkxtb******'),
  }(name='VMImageSpec'),
}

model AddImageShrinkRequest {
  containerImageSpecShrink?: string(name='ContainerImageSpec'),
  description?: string(name='Description'),
  imageType?: string(name='ImageType'),
  imageVersion?: string(name='ImageVersion', example='V1.0'),
  name?: string(name='Name', description='This parameter is required.', example='app-image'),
  VMImageSpecShrink?: string(name='VMImageSpec'),
}

model AddImageResponseBody = {
  imageId?: string(name='ImageId', example='m-bp1akkkr1rkxtb******'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE73368'),
  success?: boolean(name='Success', example='True'),
}

model AddImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddImageResponseBody(name='body'),
}

/**
 * @summary 添加托管侧用户自定义镜像
 *
 * @param tmpReq AddImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddImageResponse
 */
async function addImageWithOptions(tmpReq: AddImageRequest, runtime: Util.RuntimeOptions): AddImageResponse {
  Util.validateModel(tmpReq);
  var request = new AddImageShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.containerImageSpec)) {
    request.containerImageSpecShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.containerImageSpec, 'ContainerImageSpec', 'json');
  }
  if (!Util.isUnset(tmpReq.VMImageSpec)) {
    request.VMImageSpecShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.VMImageSpec, 'VMImageSpec', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.containerImageSpecShrink)) {
    query['ContainerImageSpec'] = request.containerImageSpecShrink;
  }
  if (!Util.isUnset(request.description)) {
    query['Description'] = request.description;
  }
  if (!Util.isUnset(request.imageType)) {
    query['ImageType'] = request.imageType;
  }
  if (!Util.isUnset(request.imageVersion)) {
    query['ImageVersion'] = request.imageVersion;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.VMImageSpecShrink)) {
    query['VMImageSpec'] = request.VMImageSpecShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddImage',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 添加托管侧用户自定义镜像
 *
 * @param request AddImageRequest
 * @return AddImageResponse
 */
async function addImage(request: AddImageRequest): AddImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return addImageWithOptions(request, runtime);
}

model CreateJobRequest {
  deploymentPolicy?: {
    allocationSpec?: string(name='AllocationSpec', example='Dedicated'),
    level?: string(name='Level'),
    network?: {
      enableExternalIpAddress?: boolean(name='EnableExternalIpAddress'),
      vswitch?: [ string ](name='Vswitch'),
    }(name='Network'),
    tag?: [ 
      {
        key?: string(name='Key', description='This parameter is required.'),
        value?: string(name='Value'),
      }
    ](name='Tag'),
  }(name='DeploymentPolicy'),
  jobDescription?: string(name='JobDescription', example='Demo'),
  jobName?: string(name='JobName', description='This parameter is required.', example='testjob'),
  jobScheduler?: string(name='JobScheduler'),
  securityPolicy?: {
    securityGroup?: {
      securityGroupIds?: [ string ](name='SecurityGroupIds'),
    }(name='SecurityGroup'),
  }(name='SecurityPolicy'),
  tasks?: [ 
    {
      executorPolicy?: {
        arraySpec?: {
          indexEnd?: int32(name='IndexEnd', example='9'),
          indexStart?: int32(name='IndexStart', example='0'),
          indexStep?: int32(name='IndexStep', example='1'),
        }(name='ArraySpec'),
        maxCount?: int32(name='MaxCount', example='1'),
      }(name='ExecutorPolicy'),
      taskName?: string(name='TaskName', example='task0'),
      taskSpec?: {
        resource?: {
          cores?: float(name='Cores', example='2'),
          disks?: [ 
            {
              size?: int32(name='Size', example='40'),
              type?: string(name='Type', example='System'),
            }
          ](name='Disks'),
          memory?: float(name='Memory', example='4'),
        }(name='Resource'),
        taskExecutor?: [ 
          {
            container?: {
              appId?: string(name='AppId'),
              command?: [ string ](name='Command'),
              environmentVars?: [ 
                {
                  name?: string(name='Name', example='PATH'),
                  value?: string(name='Value', example='/usr/local/bin'),
                }
              ](name='EnvironmentVars'),
              image?: string(name='Image', description='This parameter is required.', example='registry-vpc.cn-hangzhou.aliyuncs.com/ehpc/hpl:latest'),
              workingDir?: string(name='WorkingDir', example='/usr/local/'),
            }(name='Container'),
            VM?: {
              appId?: string(name='AppId'),
              image?: string(name='Image', description='This parameter is required.', example='m-xxxx'),
              prologScript?: string(name='PrologScript', example='ZWNobyBoZWxsbyBlY3Mh'),
              script?: string(name='Script', example='ZWNobyBoZWxsbyBlY3Mh'),
            }(name='VM'),
          }
        ](name='TaskExecutor', description='This parameter is required.'),
        volumeMount?: [ 
          {
            mountOptions?: string(name='MountOptions', example='{"server":"xxxxx-xxxxx.cn-heyuan.nas.aliyuncs.com","vers":"3","path":"/data","options":"nolock,tcp,noresvport"}'),
            mountPath?: string(name='MountPath', example='/mnt'),
            volumeDriver?: string(name='VolumeDriver', example='alicloud/nas'),
          }
        ](name='VolumeMount'),
      }(name='TaskSpec'),
      taskSustainable?: boolean(name='TaskSustainable', example='true'),
    }
  ](name='Tasks', description='This parameter is required.'),
}

model CreateJobShrinkRequest {
  deploymentPolicyShrink?: string(name='DeploymentPolicy'),
  jobDescription?: string(name='JobDescription', example='Demo'),
  jobName?: string(name='JobName', description='This parameter is required.', example='testjob'),
  jobScheduler?: string(name='JobScheduler'),
  securityPolicyShrink?: string(name='SecurityPolicy'),
  tasksShrink?: string(name='Tasks', description='This parameter is required.'),
}

model CreateJobResponseBody = {
  jobId?: string(name='JobId', example='job-xxxx'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  tasks?: [ 
    {
      executorIds?: [ string ](name='ExecutorIds'),
      taskName?: string(name='TaskName'),
    }
  ](name='Tasks'),
}

model CreateJobResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateJobResponseBody(name='body'),
}

/**
 * @summary 提交任务
 *
 * @param tmpReq CreateJobRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateJobResponse
 */
async function createJobWithOptions(tmpReq: CreateJobRequest, runtime: Util.RuntimeOptions): CreateJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.deploymentPolicy)) {
    request.deploymentPolicyShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.deploymentPolicy, 'DeploymentPolicy', 'json');
  }
  if (!Util.isUnset(tmpReq.securityPolicy)) {
    request.securityPolicyShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.securityPolicy, 'SecurityPolicy', 'json');
  }
  if (!Util.isUnset(tmpReq.tasks)) {
    request.tasksShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.tasks, 'Tasks', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.deploymentPolicyShrink)) {
    query['DeploymentPolicy'] = request.deploymentPolicyShrink;
  }
  if (!Util.isUnset(request.jobDescription)) {
    query['JobDescription'] = request.jobDescription;
  }
  if (!Util.isUnset(request.jobName)) {
    query['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobScheduler)) {
    query['JobScheduler'] = request.jobScheduler;
  }
  if (!Util.isUnset(request.securityPolicyShrink)) {
    query['SecurityPolicy'] = request.securityPolicyShrink;
  }
  if (!Util.isUnset(request.tasksShrink)) {
    query['Tasks'] = request.tasksShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateJob',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 提交任务
 *
 * @param request CreateJobRequest
 * @return CreateJobResponse
 */
async function createJob(request: CreateJobRequest): CreateJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createJobWithOptions(request, runtime);
}

model CreatePoolRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
  priority?: int32(name='Priority', example='1'),
  resourceLimits?: {
    maxExectorNum?: int32(name='MaxExectorNum', example='2000'),
  }(name='ResourceLimits'),
}

model CreatePoolShrinkRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
  priority?: int32(name='Priority', example='1'),
  resourceLimitsShrink?: string(name='ResourceLimits'),
}

model CreatePoolResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model CreatePoolResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreatePoolResponseBody(name='body'),
}

/**
 * @summary 创建资源池
 *
 * @param tmpReq CreatePoolRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreatePoolResponse
 */
async function createPoolWithOptions(tmpReq: CreatePoolRequest, runtime: Util.RuntimeOptions): CreatePoolResponse {
  Util.validateModel(tmpReq);
  var request = new CreatePoolShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.resourceLimits)) {
    request.resourceLimitsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.resourceLimits, 'ResourceLimits', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.priority)) {
    query['Priority'] = request.priority;
  }
  if (!Util.isUnset(request.resourceLimitsShrink)) {
    query['ResourceLimits'] = request.resourceLimitsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreatePool',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建资源池
 *
 * @param request CreatePoolRequest
 * @return CreatePoolResponse
 */
async function createPool(request: CreatePoolRequest): CreatePoolResponse {
  var runtime = new Util.RuntimeOptions{};
  return createPoolWithOptions(request, runtime);
}

model DeleteJobsRequest {
  executorIds?: [ string ](name='ExecutorIds'),
  jobSpec?: [ 
    {
      jobId?: string(name='JobId', example='job-xxxx'),
      taskSpec?: [ 
        {
          arrayIndex?: [ int32 ](name='ArrayIndex'),
          taskName?: string(name='TaskName', example='task0'),
        }
      ](name='TaskSpec'),
    }
  ](name='JobSpec'),
}

model DeleteJobsShrinkRequest {
  executorIdsShrink?: string(name='ExecutorIds'),
  jobSpecShrink?: string(name='JobSpec'),
}

model DeleteJobsResponseBody = {
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
}

model DeleteJobsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteJobsResponseBody(name='body'),
}

/**
 * @summary 删除作业
 *
 * @param tmpReq DeleteJobsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteJobsResponse
 */
async function deleteJobsWithOptions(tmpReq: DeleteJobsRequest, runtime: Util.RuntimeOptions): DeleteJobsResponse {
  Util.validateModel(tmpReq);
  var request = new DeleteJobsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.executorIds)) {
    request.executorIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.executorIds, 'ExecutorIds', 'json');
  }
  if (!Util.isUnset(tmpReq.jobSpec)) {
    request.jobSpecShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.jobSpec, 'JobSpec', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.executorIdsShrink)) {
    query['ExecutorIds'] = request.executorIdsShrink;
  }
  if (!Util.isUnset(request.jobSpecShrink)) {
    query['JobSpec'] = request.jobSpecShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteJobs',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除作业
 *
 * @param request DeleteJobsRequest
 * @return DeleteJobsResponse
 */
async function deleteJobs(request: DeleteJobsRequest): DeleteJobsResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteJobsWithOptions(request, runtime);
}

model DeletePoolRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
}

model DeletePoolResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model DeletePoolResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeletePoolResponseBody(name='body'),
}

/**
 * @summary 删除资源池
 *
 * @param request DeletePoolRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeletePoolResponse
 */
async function deletePoolWithOptions(request: DeletePoolRequest, runtime: Util.RuntimeOptions): DeletePoolResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeletePool',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除资源池
 *
 * @param request DeletePoolRequest
 * @return DeletePoolResponse
 */
async function deletePool(request: DeletePoolRequest): DeletePoolResponse {
  var runtime = new Util.RuntimeOptions{};
  return deletePoolWithOptions(request, runtime);
}

model DescribeJobMetricDataRequest {
  arrayIndex?: [ int32 ](name='ArrayIndex'),
  jobId?: string(name='JobId', example='job-xxxxx'),
  metricName?: string(name='MetricName', example='cpu_utilization'),
  taskName?: string(name='TaskName', example='Task0'),
}

model DescribeJobMetricDataShrinkRequest {
  arrayIndexShrink?: string(name='ArrayIndex'),
  jobId?: string(name='JobId', example='job-xxxxx'),
  metricName?: string(name='MetricName', example='cpu_utilization'),
  taskName?: string(name='TaskName', example='Task0'),
}

model DescribeJobMetricDataResponseBody = {
  dataPoints?: string(name='DataPoints', example='[{"timestamp":1709540685000,"Minimum":28.45,"Maximum":28.45,"Average":28.45}]'),
  period?: int32(name='Period', example='15'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
}

model DescribeJobMetricDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeJobMetricDataResponseBody(name='body'),
}

/**
 * @summary 查询作业性能数据
 *
 * @param tmpReq DescribeJobMetricDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeJobMetricDataResponse
 */
async function describeJobMetricDataWithOptions(tmpReq: DescribeJobMetricDataRequest, runtime: Util.RuntimeOptions): DescribeJobMetricDataResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeJobMetricDataShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.arrayIndex)) {
    request.arrayIndexShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.arrayIndex, 'ArrayIndex', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.arrayIndexShrink)) {
    query['ArrayIndex'] = request.arrayIndexShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    query['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.taskName)) {
    query['TaskName'] = request.taskName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeJobMetricData',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询作业性能数据
 *
 * @param request DescribeJobMetricDataRequest
 * @return DescribeJobMetricDataResponse
 */
async function describeJobMetricData(request: DescribeJobMetricDataRequest): DescribeJobMetricDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeJobMetricDataWithOptions(request, runtime);
}

model DescribeJobMetricLastRequest {
  arrayIndex?: [ int32 ](name='ArrayIndex'),
  jobId?: string(name='JobId', example='job-xxxxx'),
  taskName?: string(name='TaskName', example='Task0'),
}

model DescribeJobMetricLastShrinkRequest {
  arrayIndexShrink?: string(name='ArrayIndex'),
  jobId?: string(name='JobId', example='job-xxxxx'),
  taskName?: string(name='TaskName', example='Task0'),
}

model DescribeJobMetricLastResponseBody = {
  metrics?: [ 
    {
      arrayIndex?: int32(name='ArrayIndex', example='1'),
      metric?: string(name='Metric', example='{"memory_utilization": 37.42,"cpu_utilization": 1.008, "disk_utilization": 3.562}'),
    }
  ](name='Metrics'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
}

model DescribeJobMetricLastResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeJobMetricLastResponseBody(name='body'),
}

/**
 * @summary 查询作业即时监控项
 *
 * @param tmpReq DescribeJobMetricLastRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeJobMetricLastResponse
 */
async function describeJobMetricLastWithOptions(tmpReq: DescribeJobMetricLastRequest, runtime: Util.RuntimeOptions): DescribeJobMetricLastResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeJobMetricLastShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.arrayIndex)) {
    request.arrayIndexShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.arrayIndex, 'ArrayIndex', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.arrayIndexShrink)) {
    query['ArrayIndex'] = request.arrayIndexShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    query['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.taskName)) {
    query['TaskName'] = request.taskName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeJobMetricLast',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询作业即时监控项
 *
 * @param request DescribeJobMetricLastRequest
 * @return DescribeJobMetricLastResponse
 */
async function describeJobMetricLast(request: DescribeJobMetricLastRequest): DescribeJobMetricLastResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeJobMetricLastWithOptions(request, runtime);
}

model GetAppVersionsRequest {
  appName?: string(name='AppName', description='This parameter is required.', example='V-Ray'),
  imageCategory?: string(name='ImageCategory', example='Public'),
  imageType?: string(name='ImageType', example='VM'),
  pageNumber?: long(name='PageNumber', example='1'),
  pageSize?: long(name='PageSize', example='10'),
}

model GetAppVersionsResponseBody = {
  appVersions?: [ 
    {
      imageId?: string(name='ImageId', description='This parameter is required.', example='m-f8z0dfa96luomqly****'),
      name?: string(name='Name', example='V-Ray'),
      version?: string(name='Version', example='v1.0'),
    }
  ](name='AppVersions'),
  pageNumber?: long(name='PageNumber', example='1'),
  pageSize?: long(name='PageSize', example='20'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
  success?: boolean(name='Success', example='true'),
  totalCount?: int32(name='TotalCount', example='1'),
}

model GetAppVersionsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAppVersionsResponseBody(name='body'),
}

/**
 * @summary 查看应用版本列表
 *
 * @param request GetAppVersionsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetAppVersionsResponse
 */
async function getAppVersionsWithOptions(request: GetAppVersionsRequest, runtime: Util.RuntimeOptions): GetAppVersionsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.appName)) {
    query['AppName'] = request.appName;
  }
  if (!Util.isUnset(request.imageCategory)) {
    query['ImageCategory'] = request.imageCategory;
  }
  if (!Util.isUnset(request.imageType)) {
    query['ImageType'] = request.imageType;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAppVersions',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查看应用版本列表
 *
 * @param request GetAppVersionsRequest
 * @return GetAppVersionsResponse
 */
async function getAppVersions(request: GetAppVersionsRequest): GetAppVersionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAppVersionsWithOptions(request, runtime);
}

model GetImageRequest {
  imageCategory?: string(name='ImageCategory'),
  imageId?: string(name='ImageId', description='This parameter is required.', example='m-2ze74g5mvy4pjg*****'),
  imageType?: string(name='ImageType'),
}

model GetImageResponseBody = {
  image?: {
    appId?: string(name='AppId'),
    containerImageSpec?: {
      architecture?: string(name='Architecture'),
      isACREnterprise?: boolean(name='IsACREnterprise', example='True'),
      isACRRegistry?: boolean(name='IsACRRegistry', example='True'),
      osTag?: string(name='OsTag'),
      platform?: string(name='Platform'),
      registryCredential?: {
        password?: string(name='Password', example='userpassword'),
        server?: string(name='Server', example='registry-vpc.cn-hangzhou.aliyuncs.com'),
        userName?: string(name='UserName', example='username'),
      }(name='RegistryCredential'),
      registryCriId?: string(name='RegistryCriId', example='cri-xyz795ygf8k9****'),
      registryUrl?: string(name='RegistryUrl', example='registry-vpc.cn-hangzhou.aliyuncs.com/ehpc_open/nginx:latest'),
    }(name='ContainerImageSpec'),
    createTime?: string(name='CreateTime', example='2022-12-23T09:51:39Z'),
    description?: string(name='Description'),
    documentInfo?: {
      document?: string(name='Document'),
      documentId?: string(name='DocumentId'),
      encodingMode?: string(name='EncodingMode'),
    }(name='DocumentInfo'),
    imageType?: string(name='ImageType', description='This parameter is required.', example='VM'),
    name?: string(name='Name', example='app-image'),
    size?: string(name='Size', example='40 GiB'),
    status?: string(name='Status'),
    VMImageSpec?: {
      architecture?: string(name='Architecture', example='x86_64'),
      imageId?: string(name='ImageId', example='m-uf60twafjtaart******'),
      osTag?: string(name='OsTag', example='CentOS  7.6 64 bit'),
      platform?: string(name='Platform', example='CentOS'),
    }(name='VMImageSpec'),
    version?: string(name='Version', example='v1.0'),
  }(name='Image'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE73368'),
  success?: boolean(name='Success', example='true'),
  totalCount?: int32(name='TotalCount', example='10'),
}

model GetImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetImageResponseBody(name='body'),
}

/**
 * @summary 查询托管侧镜像详情。
 *
 * @param request GetImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetImageResponse
 */
async function getImageWithOptions(request: GetImageRequest, runtime: Util.RuntimeOptions): GetImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.imageCategory)) {
    query['ImageCategory'] = request.imageCategory;
  }
  if (!Util.isUnset(request.imageId)) {
    query['ImageId'] = request.imageId;
  }
  if (!Util.isUnset(request.imageType)) {
    query['ImageType'] = request.imageType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetImage',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询托管侧镜像详情。
 *
 * @param request GetImageRequest
 * @return GetImageResponse
 */
async function getImage(request: GetImageRequest): GetImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImageWithOptions(request, runtime);
}

model GetJobRequest {
  jobId?: string(name='JobId', example='job-xxxx'),
}

model GetJobResponseBody = {
  jobInfo?: {
    createTime?: string(name='CreateTime', example='2024-03-05 20:00:46'),
    deploymentPolicy?: {
      allocationSpec?: string(name='AllocationSpec', example='Dedicated'),
      level?: string(name='Level'),
      network?: {
        enableENIMapping?: boolean(name='EnableENIMapping'),
        enableExternalIpAddress?: boolean(name='EnableExternalIpAddress'),
        vswitch?: [ string ](name='Vswitch'),
      }(name='Network'),
      tags?: [ 
        {
          tagKey?: string(name='TagKey'),
          tagValue?: string(name='TagValue'),
        }
      ](name='Tags'),
    }(name='DeploymentPolicy'),
    endTime?: string(name='EndTime', example='2024-03-05 20:01:48'),
    jobDescription?: string(name='JobDescription', example='Demo'),
    jobId?: string(name='JobId', example='job-xxxx'),
    jobName?: string(name='JobName', example='testJob'),
    jobScheduler?: string(name='JobScheduler'),
    startTime?: string(name='StartTime', example='2024-03-05 20:00:48'),
    status?: string(name='Status', example='Succeed'),
    tasks?: [ 
      {
        executorPolicy?: {
          arraySpec?: {
            indexEnd?: int32(name='IndexEnd', example='9'),
            indexStart?: int32(name='IndexStart', example='0'),
            indexStep?: int32(name='IndexStep', example='1'),
          }(name='ArraySpec'),
          maxCount?: int32(name='MaxCount', example='10'),
        }(name='ExecutorPolicy'),
        executorStatus?: [ 
          {
            arrayId?: int32(name='ArrayId', example='0'),
            createTime?: string(name='CreateTime', example='2024-02-04 13:54:10'),
            endTime?: string(name='EndTime', example='2024-02-04 13:54:10'),
            startTime?: string(name='StartTime', example='2024-02-04 13:54:10'),
            status?: string(name='Status', example='Running'),
            statusReason?: string(name='StatusReason', example='Creating executor'),
          }
        ](name='ExecutorStatus'),
        taskName?: string(name='TaskName', example='task0'),
        taskSpec?: {
          resource?: {
            cores?: float(name='Cores', example='1'),
            disks?: [ 
              {
                size?: int32(name='Size', example='100'),
                type?: string(name='Type', example='System'),
              }
            ](name='Disks'),
            memory?: int32(name='Memory', example='4'),
          }(name='Resource'),
          taskExecutor?: [ 
            {
              VM?: {
                image?: string(name='Image', example='m-xxxx'),
                prologScript?: string(name='PrologScript', example='ZWNobyAiMTIzNCIgPiBgZGF0ZSArJXNg'),
                script?: string(name='Script', example='ZWNobyAiMTIzNCIgPiBgZGF0ZSArJXNg'),
              }(name='VM'),
            }
          ](name='TaskExecutor'),
        }(name='TaskSpec'),
        taskSustainable?: boolean(name='TaskSustainable', example='true'),
      }
    ](name='Tasks'),
  }(name='JobInfo'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model GetJobResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetJobResponseBody(name='body'),
}

/**
 * @summary 查询作业详情
 *
 * @param request GetJobRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetJobResponse
 */
async function getJobWithOptions(request: GetJobRequest, runtime: Util.RuntimeOptions): GetJobResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jobId)) {
    query['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetJob',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询作业详情
 *
 * @param request GetJobRequest
 * @return GetJobResponse
 */
async function getJob(request: GetJobRequest): GetJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJobWithOptions(request, runtime);
}

model GetPoolRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
}

model GetPoolResponseBody = {
  poolInfo?: {
    createTime?: string(name='CreateTime', example='2024-12-01 20:00:00'),
    exectorUsage?: int32(name='ExectorUsage', example='1'),
    isDefault?: boolean(name='IsDefault', example='true'),
    maxExectorNum?: int32(name='MaxExectorNum', example='2000'),
    poolName?: string(name='PoolName', example='PoolTest'),
    priority?: int32(name='Priority', example='1'),
    reason?: string(name='Reason', example='Fails to *** pool: ***.'),
    status?: string(name='Status', example='Working'),
    updateTime?: string(name='UpdateTime', example='2024-12-01 20:00:00'),
  }(name='PoolInfo'),
  requestId?: string(name='RequestId', description='Id of the request', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model GetPoolResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPoolResponseBody(name='body'),
}

/**
 * @summary 查询队列详细信息
 *
 * @param request GetPoolRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetPoolResponse
 */
async function getPoolWithOptions(request: GetPoolRequest, runtime: Util.RuntimeOptions): GetPoolResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPool',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询队列详细信息
 *
 * @param request GetPoolRequest
 * @return GetPoolResponse
 */
async function getPool(request: GetPoolRequest): GetPoolResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPoolWithOptions(request, runtime);
}

model ListExecutorsRequest {
  filter?: {
    executorIds?: [ string ](name='ExecutorIds'),
    ipAddresses?: [ string ](name='IpAddresses'),
    jobName?: string(name='JobName', example='testJob'),
    status?: [ string ](name='Status'),
    timeCreatedAfter?: int32(name='TimeCreatedAfter', example='1703819914'),
    timeCreatedBefore?: int32(name='TimeCreatedBefore', example='1703820113'),
  }(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='50'),
}

model ListExecutorsShrinkRequest {
  filterShrink?: string(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='50'),
}

model ListExecutorsResponseBody = {
  executors?: [ 
    {
      appName?: string(name='AppName'),
      arrayIndex?: int32(name='ArrayIndex', example='0'),
      createTime?: string(name='CreateTime', example='2024-02-20 10:04:10'),
      endTime?: string(name='EndTime', example='2024-02-20 10:04:18'),
      executorId?: string(name='ExecutorId', example='job-xxxx-task0-1'),
      expirationTime?: string(name='ExpirationTime'),
      externalIpAddress?: [ string ](name='ExternalIpAddress'),
      hostName?: [ string ](name='HostName'),
      image?: string(name='Image'),
      ipAddress?: [ string ](name='IpAddress'),
      jobId?: string(name='JobId', example='job-hy1nggvyukuvkr******'),
      jobName?: string(name='JobName', example='testJob'),
      resource?: {
        cores?: float(name='Cores'),
        disks?: [ 
          {
            size?: int32(name='Size'),
            type?: string(name='Type'),
          }
        ](name='Disks'),
        memory?: float(name='Memory'),
      }(name='Resource'),
      resourceType?: string(name='ResourceType'),
      startTime?: string(name='StartTime'),
      status?: string(name='Status', example='Running'),
      statusReason?: string(name='StatusReason', example='Succeeded to release executor resource'),
      tags?: [ 
        {
          tagKey?: string(name='TagKey'),
          tagValue?: string(name='TagValue'),
        }
      ](name='Tags'),
      taskName?: string(name='TaskName', example='task0'),
      taskSustainable?: boolean(name='TaskSustainable'),
      vswitchId?: string(name='VswitchId'),
    }
  ](name='Executors'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='50'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  totalCount?: string(name='TotalCount', example='40'),
}

model ListExecutorsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListExecutorsResponseBody(name='body'),
}

/**
 * @summary 查询全局Executor信息
 *
 * @param tmpReq ListExecutorsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListExecutorsResponse
 */
async function listExecutorsWithOptions(tmpReq: ListExecutorsRequest, runtime: Util.RuntimeOptions): ListExecutorsResponse {
  Util.validateModel(tmpReq);
  var request = new ListExecutorsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.filter)) {
    request.filterShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.filter, 'Filter', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.filterShrink)) {
    query['Filter'] = request.filterShrink;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListExecutors',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询全局Executor信息
 *
 * @param request ListExecutorsRequest
 * @return ListExecutorsResponse
 */
async function listExecutors(request: ListExecutorsRequest): ListExecutorsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listExecutorsWithOptions(request, runtime);
}

model ListImagesRequest {
  imageCategory?: string(name='ImageCategory'),
  imageIds?: [ string ](name='ImageIds'),
  imageNames?: [ string ](name='ImageNames'),
  imageType?: string(name='ImageType'),
  mode?: string(name='Mode'),
  pageNumber?: long(name='PageNumber', example='1'),
  pageSize?: long(name='PageSize', example='10'),
}

model ListImagesShrinkRequest {
  imageCategory?: string(name='ImageCategory'),
  imageIdsShrink?: string(name='ImageIds'),
  imageNamesShrink?: string(name='ImageNames'),
  imageType?: string(name='ImageType'),
  mode?: string(name='Mode'),
  pageNumber?: long(name='PageNumber', example='1'),
  pageSize?: long(name='PageSize', example='10'),
}

model ListImagesResponseBody = {
  images?: [ 
    {
      appId?: string(name='AppId', description='This parameter is required.'),
      createTime?: string(name='CreateTime', example='2022-12-09T07:06:34Z'),
      description?: string(name='Description'),
      documentId?: int32(name='DocumentId'),
      imageId?: string(name='ImageId', description='This parameter is required.', example='m-bp181x855551ww5yq****'),
      imageType?: string(name='ImageType', description='This parameter is required.', example='VM'),
      name?: string(name='Name', example='app-image'),
      osTag?: string(name='OsTag'),
      updateTime?: string(name='UpdateTime'),
      version?: string(name='Version', example='v1.0'),
      weight?: int32(name='Weight'),
    }
  ](name='Images'),
  pageNumber?: long(name='PageNumber', example='1'),
  pageSize?: long(name='PageSize', example='20'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  success?: boolean(name='Success', example='true'),
  totalCount?: int32(name='TotalCount', example='1'),
}

model ListImagesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListImagesResponseBody(name='body'),
}

/**
 * @summary 查看托管侧镜像列表
 *
 * @param tmpReq ListImagesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListImagesResponse
 */
async function listImagesWithOptions(tmpReq: ListImagesRequest, runtime: Util.RuntimeOptions): ListImagesResponse {
  Util.validateModel(tmpReq);
  var request = new ListImagesShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.imageIds)) {
    request.imageIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.imageIds, 'ImageIds', 'json');
  }
  if (!Util.isUnset(tmpReq.imageNames)) {
    request.imageNamesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.imageNames, 'ImageNames', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.imageCategory)) {
    query['ImageCategory'] = request.imageCategory;
  }
  if (!Util.isUnset(request.imageIdsShrink)) {
    query['ImageIds'] = request.imageIdsShrink;
  }
  if (!Util.isUnset(request.imageNamesShrink)) {
    query['ImageNames'] = request.imageNamesShrink;
  }
  if (!Util.isUnset(request.imageType)) {
    query['ImageType'] = request.imageType;
  }
  if (!Util.isUnset(request.mode)) {
    query['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListImages',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查看托管侧镜像列表
 *
 * @param request ListImagesRequest
 * @return ListImagesResponse
 */
async function listImages(request: ListImagesRequest): ListImagesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listImagesWithOptions(request, runtime);
}

model ListJobExecutorsRequest {
  jobId?: string(name='JobId', example='job-xxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  taskName?: string(name='TaskName', example='task0'),
}

model ListJobExecutorsResponseBody = {
  executorStatus?: {
    deleted?: int32(name='Deleted'),
    exception?: int32(name='Exception'),
    failed?: int32(name='Failed'),
    initing?: int32(name='Initing'),
    pending?: int32(name='Pending'),
    running?: int32(name='Running'),
    succeeded?: int32(name='Succeeded'),
  }(name='ExecutorStatus'),
  executors?: [ 
    {
      arrayIndex?: int32(name='ArrayIndex', example='0'),
      createTime?: string(name='CreateTime', example='2024-02-20 10:04:10'),
      endTime?: string(name='EndTime', example='2024-02-20 10:04:18'),
      executorId?: string(name='ExecutorId'),
      expirationTime?: string(name='ExpirationTime'),
      externalIpAddress?: [ string ](name='ExternalIpAddress'),
      hostName?: [ string ](name='HostName'),
      ipAddress?: [ string ](name='IpAddress'),
      startTime?: string(name='StartTime'),
      status?: string(name='Status', example='Running'),
      statusReason?: string(name='StatusReason', example='Creating executor'),
      tags?: [ 
        {
          tagKey?: string(name='TagKey'),
          tagValue?: string(name='TagValue'),
        }
      ](name='Tags'),
    }
  ](name='Executors'),
  jobId?: string(name='JobId', example='job-xxxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  taskName?: string(name='TaskName', example='task0'),
  totalCount?: string(name='TotalCount', example='50'),
}

model ListJobExecutorsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListJobExecutorsResponseBody(name='body'),
}

/**
 * @summary 查询作业Executor信息
 *
 * @param request ListJobExecutorsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListJobExecutorsResponse
 */
async function listJobExecutorsWithOptions(request: ListJobExecutorsRequest, runtime: Util.RuntimeOptions): ListJobExecutorsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jobId)) {
    query['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.taskName)) {
    query['TaskName'] = request.taskName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListJobExecutors',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询作业Executor信息
 *
 * @param request ListJobExecutorsRequest
 * @return ListJobExecutorsResponse
 */
async function listJobExecutors(request: ListJobExecutorsRequest): ListJobExecutorsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listJobExecutorsWithOptions(request, runtime);
}

model ListJobsRequest {
  filter?: {
    jobId?: string(name='JobId', example='job-xxxx'),
    jobName?: string(name='JobName', example='testJob'),
    status?: string(name='Status', example='Running'),
    timeCreatedAfter?: int32(name='TimeCreatedAfter', example='1703819914'),
    timeCreatedBefore?: int32(name='TimeCreatedBefore', example='1703820113'),
  }(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='50'),
  sortBy?: {
    label?: string(name='Label', example='time_start'),
    order?: string(name='Order', example='ASC'),
  }(name='SortBy'),
}

model ListJobsShrinkRequest {
  filterShrink?: string(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='50'),
  sortByShrink?: string(name='SortBy'),
}

model ListJobsResponseBody = {
  jobList?: [ 
    {
      appName?: string(name='AppName'),
      createTime?: string(name='CreateTime', example='2024-01-25 12:29:21'),
      endTime?: string(name='EndTime', example='2024-01-25 12:35:23'),
      executorCount?: int32(name='ExecutorCount', example='1'),
      jobDescription?: string(name='JobDescription', example='Demo'),
      jobId?: string(name='JobId', example='job-xxx'),
      jobName?: string(name='JobName', example='testJob'),
      ownerUid?: string(name='OwnerUid', example='129**********'),
      startTime?: string(name='StartTime', example='2024-01-25 12:29:23'),
      status?: string(name='Status', example='Running'),
      tags?: [ 
        {
          tagKey?: string(name='TagKey'),
          tagValue?: string(name='TagValue'),
        }
      ](name='Tags'),
      taskCount?: int32(name='TaskCount', example='1'),
      taskSustainable?: boolean(name='TaskSustainable', example='true'),
    }
  ](name='JobList'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  totalCount?: int32(name='TotalCount', example='1'),
}

model ListJobsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListJobsResponseBody(name='body'),
}

/**
 * @summary 查询作业列表
 *
 * @param tmpReq ListJobsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListJobsResponse
 */
async function listJobsWithOptions(tmpReq: ListJobsRequest, runtime: Util.RuntimeOptions): ListJobsResponse {
  Util.validateModel(tmpReq);
  var request = new ListJobsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.filter)) {
    request.filterShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.filter, 'Filter', 'json');
  }
  if (!Util.isUnset(tmpReq.sortBy)) {
    request.sortByShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.sortBy, 'SortBy', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.filterShrink)) {
    query['Filter'] = request.filterShrink;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sortByShrink)) {
    query['SortBy'] = request.sortByShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListJobs',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询作业列表
 *
 * @param request ListJobsRequest
 * @return ListJobsResponse
 */
async function listJobs(request: ListJobsRequest): ListJobsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listJobsWithOptions(request, runtime);
}

model ListPoolsRequest {
  filter?: {
    poolName?: [ string ](name='PoolName'),
    status?: [ string ](name='Status'),
    timeCreatedAfter?: int32(name='TimeCreatedAfter', example='1703819914'),
    timeCreatedBefore?: int32(name='TimeCreatedBefore', example='1703820113'),
  }(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
}

model ListPoolsShrinkRequest {
  filterShrink?: string(name='Filter'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
}

model ListPoolsResponseBody = {
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  poolList?: [ 
    {
      isDefault?: boolean(name='IsDefault', example='true'),
      maxExectorNum?: int32(name='MaxExectorNum', example='2000'),
      poolName?: string(name='PoolName', example='PoolTest'),
      priority?: int32(name='Priority', example='1'),
      status?: string(name='Status', example='Working'),
    }
  ](name='PoolList'),
  requestId?: string(name='RequestId', description='Id of the request', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  totalCount?: int32(name='TotalCount', example='2'),
}

model ListPoolsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListPoolsResponseBody(name='body'),
}

/**
 * @summary 查询资源池列表
 *
 * @param tmpReq ListPoolsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListPoolsResponse
 */
async function listPoolsWithOptions(tmpReq: ListPoolsRequest, runtime: Util.RuntimeOptions): ListPoolsResponse {
  Util.validateModel(tmpReq);
  var request = new ListPoolsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.filter)) {
    request.filterShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.filter, 'Filter', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.filterShrink)) {
    query['Filter'] = request.filterShrink;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListPools',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询资源池列表
 *
 * @param request ListPoolsRequest
 * @return ListPoolsResponse
 */
async function listPools(request: ListPoolsRequest): ListPoolsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPoolsWithOptions(request, runtime);
}

model ListTagResourcesRequest {
  maxResult?: int32(name='MaxResult', example='20'),
  nextToken?: string(name='NextToken', example='1d2db86scXXXXXXXXXX'),
  resourceId?: [ string ](name='ResourceId'),
  resourceType?: string(name='ResourceType', description='This parameter is required.', example='Job'),
  tag?: [ 
    {
      key?: string(name='Key', example='TestKey'),
      value?: string(name='Value', example='TestValue'),
    }
  ](name='Tag'),
}

model ListTagResourcesResponseBody = {
  nextToken?: string(name='NextToken', example='1d2db86scXXXXXXXXXX'),
  requestId?: string(name='RequestId', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
  tagResources?: {
    tagResource?: [ 
    {
      resourceId?: string(name='ResourceId', example='job-xxxxxxxx'),
      resourceType?: string(name='ResourceType', example='Job'),
      tagKey?: string(name='TagKey', example='TestKey'),
      tagValue?: string(name='TagValue', example='TestValue'),
    }
  ](name='TagResource')
  }(name='TagResources'),
}

model ListTagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListTagResourcesResponseBody(name='body'),
}

/**
 * @summary 查询一个或多个资源已经绑定的标签列表
 *
 * @param request ListTagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListTagResourcesResponse
 */
async function listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: Util.RuntimeOptions): ListTagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.maxResult)) {
    query['MaxResult'] = request.maxResult;
  }
  if (!Util.isUnset(request.nextToken)) {
    query['NextToken'] = request.nextToken;
  }
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListTagResources',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询一个或多个资源已经绑定的标签列表
 *
 * @param request ListTagResourcesRequest
 * @return ListTagResourcesResponse
 */
async function listTagResources(request: ListTagResourcesRequest): ListTagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listTagResourcesWithOptions(request, runtime);
}

model RemoveImageRequest {
  imageId?: string(name='ImageId', description='This parameter is required.', example='m-bp14wakr1rkxtb******'),
  imageType?: string(name='ImageType'),
}

model RemoveImageResponseBody = {
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
  success?: boolean(name='Success', example='true'),
}

model RemoveImageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RemoveImageResponseBody(name='body'),
}

/**
 * @summary 移除托管侧镜像信息。
 *
 * @param request RemoveImageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RemoveImageResponse
 */
async function removeImageWithOptions(request: RemoveImageRequest, runtime: Util.RuntimeOptions): RemoveImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.imageId)) {
    query['ImageId'] = request.imageId;
  }
  if (!Util.isUnset(request.imageType)) {
    query['ImageType'] = request.imageType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RemoveImage',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 移除托管侧镜像信息。
 *
 * @param request RemoveImageRequest
 * @return RemoveImageResponse
 */
async function removeImage(request: RemoveImageRequest): RemoveImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return removeImageWithOptions(request, runtime);
}

model TagResourcesRequest {
  resourceId?: [ string ](name='ResourceId', description='This parameter is required.'),
  resourceType?: string(name='ResourceType', description='This parameter is required.', example='Job'),
  tag?: [ 
    {
      key?: string(name='Key', description='This parameter is required.', example='TestKey'),
      value?: string(name='Value', example='TestValue'),
    }
  ](name='Tag', description='This parameter is required.'),
}

model TagResourcesResponseBody = {
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model TagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: TagResourcesResponseBody(name='body'),
}

/**
 * @summary 为指定的资源列表统一创建并绑定标签
 *
 * @param request TagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return TagResourcesResponse
 */
async function tagResourcesWithOptions(request: TagResourcesRequest, runtime: Util.RuntimeOptions): TagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'TagResources',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 为指定的资源列表统一创建并绑定标签
 *
 * @param request TagResourcesRequest
 * @return TagResourcesResponse
 */
async function tagResources(request: TagResourcesRequest): TagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return tagResourcesWithOptions(request, runtime);
}

model UnTagResourcesRequest {
  all?: boolean(name='All', example='False'),
  resourceId?: [ string ](name='ResourceId', description='This parameter is required.'),
  resourceType?: string(name='ResourceType', description='This parameter is required.', example='Job'),
  tagKey?: [ string ](name='TagKey'),
}

model UnTagResourcesResponseBody = {
  requestId?: string(name='RequestId', example='896D338C-E4F4-41EC-A154-D605E5DE****'),
}

model UnTagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UnTagResourcesResponseBody(name='body'),
}

/**
 * @summary 为指定的ECS资源列表统一解绑标签
 *
 * @param request UnTagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UnTagResourcesResponse
 */
async function unTagResourcesWithOptions(request: UnTagResourcesRequest, runtime: Util.RuntimeOptions): UnTagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.all)) {
    query['All'] = request.all;
  }
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.tagKey)) {
    query['TagKey'] = request.tagKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UnTagResources',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 为指定的ECS资源列表统一解绑标签
 *
 * @param request UnTagResourcesRequest
 * @return UnTagResourcesResponse
 */
async function unTagResources(request: UnTagResourcesRequest): UnTagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return unTagResourcesWithOptions(request, runtime);
}

model UpdatePoolRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
  priority?: int32(name='Priority', example='1'),
  resourceLimits?: {
    maxExectorNum?: int32(name='MaxExectorNum', example='2000'),
  }(name='ResourceLimits'),
}

model UpdatePoolShrinkRequest {
  poolName?: string(name='PoolName', description='This parameter is required.', example='PoolTest'),
  priority?: int32(name='Priority', example='1'),
  resourceLimitsShrink?: string(name='ResourceLimits'),
}

model UpdatePoolResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request', example='04F0F334-1335-436C-A1D7-6C044FE7****'),
}

model UpdatePoolResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdatePoolResponseBody(name='body'),
}

/**
 * @summary 更新资源池
 *
 * @param tmpReq UpdatePoolRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdatePoolResponse
 */
async function updatePoolWithOptions(tmpReq: UpdatePoolRequest, runtime: Util.RuntimeOptions): UpdatePoolResponse {
  Util.validateModel(tmpReq);
  var request = new UpdatePoolShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.resourceLimits)) {
    request.resourceLimitsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.resourceLimits, 'ResourceLimits', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.priority)) {
    query['Priority'] = request.priority;
  }
  if (!Util.isUnset(request.resourceLimitsShrink)) {
    query['ResourceLimits'] = request.resourceLimitsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdatePool',
    version = '2023-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 更新资源池
 *
 * @param request UpdatePoolRequest
 * @return UpdatePoolResponse
 */
async function updatePool(request: UpdatePoolRequest): UpdatePoolResponse {
  var runtime = new Util.RuntimeOptions{};
  return updatePoolWithOptions(request, runtime);
}

